GetValue<T>(long,T,GetValueDelegate) Method

Summary

Returns the value of a DICOM element.

Syntax

C++/CLI

public T GetValue<T>( 
   long tag, 
   T defaultValue, 
   GetValueDelegate getValueDelegate 
)

public: 
T^ GetValuegeneric<typename T> 
(  
   int64 tag, 
   T^ defaultValue, 
   GetValueDelegate^ getValueDelegate 
)

Parameters

tag
tag of the item to find.

defaultValue
a value of type T that is returned if the actual value cannot be retrieved.

getValueDelegate
an optional delegate that converts that extracted data to any type

Type Parameters

T
specifies the type of the value to return

Return Value

a value of type T that is the value of the DICOM element

Remarks

For information on this method, see GetValue.

Example

using Leadtools; 
using Leadtools.Dicom; 
 
 
///  
public class PersonName 
{ 
   private string[] _innerArray = new string[5] {string.Empty, string.Empty, string.Empty, string.Empty, 
                                               string.Empty }; 
 
   /// Access this person name instance as array. Index range is 
   /// bounded between 0 (family name) and 4 (name suffix). 
   public string this[int index] 
   { 
      set 
      { 
         if (value == null || value.Length < 64) 
            _innerArray[index] = value; 
         else 
            throw new DicomException("Length of new entry exceeds 64 characters."); 
      } 
 
      get { return _innerArray[index]; } 
   } 
 
   private const int _familyNameIndex = 0; 
   private const int _givenNameIndex = 1; 
   private const int _middleNameIndex = 2; 
   private const int _namePrefixIndex = 3; 
   private const int _nameSuffixIndex = 4; 
 
   /// Access person name part family name. 
   public string FamilyName 
   { 
      set 
      { 
         if (value == null || value.Length < 64) 
         { 
            _fullName = null; 
            _innerArray[_familyNameIndex] = value; 
         } 
         else 
            throw new DicomException("Length of family name exceeds 64 characters."); 
      } 
 
      get { return _innerArray[_familyNameIndex]; } 
   } 
 
   /// Access person name part given name. 
   public string GivenName 
   { 
      set 
      { 
         if (value == null || value.Length < 64) 
         { 
            _fullName = string.Empty; 
            _innerArray[_givenNameIndex] = value; 
         } 
         else 
            throw new DicomException("Length of family name exceeds 64 characters."); 
      } 
 
      get { return _innerArray[_givenNameIndex]; } 
   } 
 
   /// Access person name part middle name. 
   public string MiddleName 
   { 
      set 
      { 
         if (value == null || value.Length < 64) 
         { 
            _fullName = string.Empty; 
            _innerArray[_middleNameIndex] = value; 
         } 
         else 
            throw new DicomException("Length of family name exceeds 64 characters."); 
      } 
 
      get { return _innerArray[_middleNameIndex]; } 
   } 
 
   /// Access person name part name prefix. 
   public string NamePrefix 
   { 
      set 
      { 
         if (value == null || value.Length < 64) 
         { 
            _fullName = string.Empty; 
            _innerArray[_namePrefixIndex] = value; 
         } 
         else 
            throw new DicomException("Length of family name exceeds 64 characters."); 
      } 
 
      get { return _innerArray[_namePrefixIndex]; } 
   } 
 
   /// Access person name part name suffix. 
   public string NameSuffix 
   { 
      set 
      { 
         if (value == null || value.Length < 64) 
         { 
            _fullName = string.Empty; 
            _innerArray[_nameSuffixIndex] = value; 
         } 
         else 
            throw new DicomException("Length of family name exceeds 64 characters."); 
      } 
 
      get { return _innerArray[_nameSuffixIndex]; } 
   } 
 
   private string _fullName = string.Empty; 
   /// Access full person name string representation. According 
   /// to the DICOM standard "^" is used as separator of different 
   /// person name parts. 
   public string FullName 
   { 
      set 
      { 
         _fullName = value; 
         if (_fullName != null) 
         { 
            string[] s; 
            int i; 
 
            if (_fullName.Contains("^")) 
               s = _fullName.Split('^'); 
            else 
               s = _fullName.Split(' '); 
 
            for (i = 0; i < s.Length; i++) 
            { 
               if (s[i].Length < 64) 
               { 
                  if (i < _innerArray.Length) 
                     _innerArray[i] = s[i]; 
               } 
               else 
                  throw new DicomException("Length of family name exceeds 64 characters."); 
            } 
            for (int k = i; k < _innerArray.Length; k++) 
               _innerArray[k] = string.Empty; 
         } 
      } 
 
      get 
      { 
         if (_fullName == string.Empty) 
         { 
            _fullName = _innerArray[0]; 
            bool isNotNull = _fullName != string.Empty; 
            int i = 1; 
            while (isNotNull && i < _innerArray.Length) 
            { 
               isNotNull = _innerArray[i] != string.Empty; 
               if (isNotNull) 
                  _fullName += "^" + _innerArray[i]; 
               i++; 
            } 
         } 
         return _fullName; 
      } 
   } 
 
 
   /// Creates a new empty person name instance. 
   public PersonName() { } 
 
   /// Creates a new person name instance from specified full name. 
   /// All person name parts have to be separated by "^" according to 
   /// the DICOM standard. 
   public PersonName(string fullName) 
   { 
      FullName = fullName; 
   } 
 
   /// Creates a new person name instance from the different person name parts. 
   public PersonName(string familyName, string givenName, 
       string middleName, string namePrefix, string nameSuffix) 
   { 
      FamilyName = familyName; 
      GivenName = givenName; 
      MiddleName = middleName; 
      NamePrefix = namePrefix; 
      NameSuffix = nameSuffix; 
   } 
 
   /// Return this person name instance's. 
   public override string ToString() 
   { 
      return FullName; 
   } 
} 
 
void DumpPersonName(PersonName pn) 
{ 
   String sMsg = 
      string.Format("Family Name: {0}\nGiven Name: {1}\nMiddle Name: {2}\nName Prefix: {3}\nName Suffix: {4}", 
      pn.FamilyName, 
      pn.GivenName, 
      pn.MiddleName, 
      pn.NamePrefix, 
      pn.NameSuffix); 
   Console.WriteLine(sMsg); 
} 
 
private void DicomDataSet_GetValueWithDelegateExample() 
{ 
   // Create a DicomDataSet and add a PatientName 
   // Dicom Spec for Value Representation PN (Person Name) 
   // Elements are in this order: 
   // * family name complex 
   // * given name complex 
   // * middle name 
   // * name prefix 
   // * name suffix. 
   DicomDataSet ds = new DicomDataSet(); 
   ds.InsertElementAndSetValue(DicomTag.PatientName, "Smith^John^MiddleName^Mr.^III"); 
 
   // Get a PersonName value of an element by specifying a tag, and using a delegate 
   // Use this form when the type is not native to the dataset 
   // The data is extracted from the field as a string and passed to the provided method. 
   PersonName pn = null; 
 
   pn = ds.GetValue<PersonName>( 
      DicomTag.PatientName, 
      null, 
      delegate (string data) 
      { 
         PersonName t = new PersonName(data); 
         return t; 
      } 
      ); 
   DumpPersonName(pn); 
 
   // Another overload, specifying parent element 
   pn = ds.GetValue<PersonName>( 
      null, 
      true, 
      DicomTag.PatientName, 
      null, 
      delegate (string data) 
      { 
         PersonName t = new PersonName(data); 
         return t; 
      } 
      ); 
   DumpPersonName(pn); 
 
   // Another overload, this time passing in the DICOM element instead of a tag 
   DicomElement element = ds.FindFirstElement(null, DicomTag.PatientName, true); 
   pn = ds.GetValue<PersonName>( 
      element, 
      null, 
      delegate (string data) 
      { 
         PersonName t = new PersonName(data); 
         return t; 
      } 
      ); 
   DumpPersonName(pn); 
}

Requirements

Target Platforms

Reference

DicomDataSet Class

DicomDataSet Members

Overload List

Download our FREE evaluation

Help Version 23.0.2024.8.20

Leadtools.Dicom Assembly

Introduction

Getting Started

Namespaces

Leadtools.Dicom Namespace

Assemblies